{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Use Python in Advanced Statistics\n",
    "\n",
    "*這個學期剛剛學完了概率論與數理統計，這好趁這個機會複習一下並複習一下 `python`*\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Chapter One Probability \n",
    "\n",
    "### 隨機試驗與樣本空間（Random Experiment and Sample Space）\n",
    "\n",
    "#### 隨機試驗\n",
    "隨機試驗是概率論中一個基本的概念。概括的講，在概率論中把符合下面三個特點的試驗叫做隨機試驗：\n",
    "* 可以在向空的條件下重複進行；\n",
    "* 每次試驗的可能結果不只一個，並且事先明確試驗的所有可能結果；\n",
    "* 進行一次試驗之前不能確定哪一個結果會出現。\n",
    "\n",
    "隨機試驗有很多種，例如常出現的擲骰子，摸球，射擊等。所有的隨機試驗的結果可以分為兩類來表示：<br>\n",
    "* 數量化表示：射擊命中的次數，商場每個小時的客流量，每天經過某個收費站的車輛等，這個結果本事就是數字；\n",
    "* 非數量化表示：拋硬幣的結果（正面/反面），化驗的結果（陽性/陰性）等，這些結果是定型的，非數量化的。但是可以用示性函數來表示，例如可以規定正面（陽性）為$1$，反面為$0$，這樣就可以實現了非數量化結果的數量化。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 樣本空間（Sample Space）：\n",
    "\n",
    "* 隨機試驗的所有可能結果構成的集合。一般即為$S$（capital S）；\n",
    "* $S$ 中的元素$e$稱為樣本點（也可以叫基本事件）；\n",
    "* 事件是樣本空間的子集，同樣是一個集合。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 事件的關係\n",
    "* 事件的包含：$A \\subseteq B$;\n",
    "* 事件的相等：$A = B$;\n",
    "* 互斥事件（互不相容事件）：不能同時出現；\n",
    "* 事件的和（並）：$A cup B$\n",
    "* 事件的差： $A - B$,$A$發生，$B$不發生；\n",
    "* 對立事件（逆事件）：互斥，必須出現其中一個。\n",
    "\n",
    "<br>\n",
    "事件的運算性質就是集合的性質"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 頻率和概率\n",
    "\n",
    "#### 頻率：\n",
    "\n",
    "頻率是指$0～1$之間的一個實數，在大量重複試驗的基礎上給出了隨機事件發生可能性的估計。<br>\n",
    "概率的穩定性：在充分多次試驗中，事件的頻率總在一個定值附近擺動，而且，試驗次數越多擺動越小。這個性質叫做頻率的穩定性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 概率：\n",
    "\n",
    "概率的統計性定義：當試驗次數增加時，隨機時間$A$發生的頻率的穩定值為$p$就稱為概率。記為$P(A) = P$<br>\n",
    "概率的公理化定義：設隨機試驗對於的樣本空間為$S$。對每一個事件$A$，定義為$P(A)$，滿足：<br>\n",
    "1. 非負性：$P(A) \\geq 0$;\n",
    "2. 規範性：$P(S) = 1;\n",
    "3. 可列可加性：$A_1, A_2, \\dots 兩兩互斥，及$A_iA_j = \\oslash, i \\neq j$則 $P(\\cup A_i) = \\sum P(A_i)$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 條件概率（Conditional Probability）:\n",
    "$P(A|B)$表示在事件$B$發生的條件下，事件$A$發生的概率，相當於$A$在$B$所佔的比例。此時，樣本空間從原來的完整樣本空間$S$縮小到了$B$，由於有了條件的約束（事件$B$），使得原本的樣本空間減少了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面我們可以通過韋恩圖做示例：<br>\n",
    "plot one：條件概率的樣本空間；<br>\n",
    "plot two：條件概率應如何計算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114914e10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import sympy\n",
    "\n",
    "\n",
    "from matplotlib_venn import venn3, venn3_circles\n",
    "plt.figure(figsize=(4,4))\n",
    "v = venn2(subsets=(2,2,1), set_labels = ('A', 'B'))\n",
    "\n",
    "\n",
    "\n",
    "plt.title(\"Sample Venn diagram - plot one\")\n",
    "plt.annotate('P(AB)', xy=v.get_label_by_id('11').get_position() - np.array([0, 0.05]), xytext=(-70,-70),\n",
    "             ha='center', textcoords='offset points', bbox=dict(boxstyle='round,pad=0.5', fc='gray', alpha=0.1),\n",
    "             arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0.5',color='gray'))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x115e3f5c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import sympy\n",
    "\n",
    "\n",
    "from matplotlib_venn import venn3, venn3_circles\n",
    "plt.figure(figsize=(4,4))\n",
    "v = venn2(subsets=(2,2,1), set_labels = ('A', 'B'))\n",
    "\n",
    "c = venn2_circles(subsets=(2, 2, 1), linestyle='dashed')\n",
    "c[0].set_lw(1.0)\n",
    "c[0].set_ls('dotted')\n",
    "plt.title(\"Sample Venn diagram\")\n",
    "plt.annotate('P(AB)', xy=v.get_label_by_id('11').get_position() - np.array([0, 0.05]), xytext=(-70,-70),\n",
    "             ha='center', textcoords='offset points', bbox=dict(boxstyle='round,pad=0.5', fc='gray', alpha=0.1),\n",
    "             arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0.5',color='gray'))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$P(B|A) = \\frac{P(AB)}{P(A)}$<br>\n",
    "$P(A|B) = \\frac{P(AB)}{P(B)}$<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "例題：一個家庭中有兩個小孩，已知至少一個是女孩，問兩個都是女孩的概率是多少？（假設生男生女是等可能的）<br>\n",
    "**解**：由題意可得：樣本空間為\n",
    "    \n",
    "    S = {(兄,弟), (兄,妹),(姐,弟),(姐,妹)}<br>\n",
    "    B = {(兄,妹), (姐,弟),(姐,妹)}<br>\n",
    "    A = {(姐,妹)}<br>\n",
    "    \n",
    "由於，事件 $B$ 已經發生了，所以這時試驗的所有可能只有三種，而事件 $A$ 包含的基本事件只占其中的一種，所以有：$P(A|B) = \\frac{1}{3}$<br>\n",
    "即，在已知至少一個是女孩的請卡滾下，兩個都是女孩的概率為$\\frac{1}{3}$。在這個例子中，如果不知道事件 $B$ 發生，則事件 $A$ 發生的概率為 $P(A) = \\frac{1}{4}$ 這裡的 $P(A) \\neq P(A|B)$，其中的原因在於事件 $B$ 的發生改變了樣本空間，使它由原來的 $S$ 縮減為新的樣本空間 $S_B = B$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 隨機變量（Random Variable）\n",
    "\n",
    "在幾乎所有教材裡，介紹概率論都是從事件和樣本空間說起的，但是後面的概率論都是圍繞著隨機變量展開的。可以說前面的事件和樣本空間都是引子，引出了隨機變量這個概率論的核心概念。後面的統計學是建立在概率論的理論基礎之上的，因此可以說理解隨機變量這個概念是學習和運用概率論與數理統計的關鍵。<br>\n",
    "**隨機變量**：<br>\n",
    "\n",
    "* 首先這是一個變量，變量與常數相對，也就是說其取值是不明確的，其實隨機變量的整個取值範圍就是前面說的樣本空間；\n",
    "* 其次這個量是隨機的，也就是說它的去職代有不確定性，讓然是在樣本空間這個範圍內的。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**定義：**\n",
    "> 設隨機試驗的樣本空間是 $S$ ，若對 $S$ 中的每一個樣本點 $e$ ，都有唯一的實數值 $X(e)$ 為隨機變量，間記為 $X$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "隨機變量的定義並不複雜，但是理解起來去不是這麼直觀。\n",
    "\n",
    "* 首先，隨即變量與之前定義的事件是有關係的，因為每個樣本點本身就是一個基本事件；\n",
    "* 在前面隨機試驗結果的表示中提到，無論是數量化的結果還是非數量化的結果，即不管試驗結果是否與數值有關，都可以引入變量，使試驗結果與數建立對應關係；\n",
    "* 隨機變量本質上是一種函數，其目的就是建立試驗結果（樣本中的點，同基本事件$e$）與實數之間的對應關係（例如將“正面”影射為$1$，“反面”影射為$0$）；\n",
    "* 自變量為基本事件$e$，定義域為樣本空間$S$，值域為某個實數集合，多個自變量可以對應同一個函數值，但不允許一個自變量對應多個函數值；\n",
    "* 隨機變量$X$取某個值或某些值就表示某種事件，且具有一定的概率；\n",
    "* 隨機變量中的隨機來源於隨機試驗結果的不確定性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我們可以通過引入隨機變量，我們簡化了隨機試驗結果（事件）的表示，從而可以更加方便的對隨機試驗進行研究。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**隨機變量的分類**:<br>\n",
    "* 離散隨機變量；\n",
    "* 連續隨機變量；\n",
    "* 每類隨機變量都有其獨特的概率密度函數和概率分佈函數。\n",
    "\n",
    "**隨機變量的數字特徵**：<br>\n",
    "* 期望（均值），眾數，分位數，中位數；\n",
    "* 方差；\n",
    "* 協方差；\n",
    "* 相關係數。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 隨機變量（Random Variable）\n",
    "\n",
    "*對隨機變量以及其取值規律的研究是概率的核心內容。在上一個小結中，總結了隨機變量的概念以及隨機變量與事件的聯繫。這個小結會更加深入的討論隨機變量。*\n",
    "\n",
    "#### 隨機變量與事件\n",
    "\n",
    "隨機變量的本質是一種函數（映射關係），在古典概率模型中，“事件和事件的概率”是核心概念；但是在現代概率論中，“隨機變量及其取值規律”是核心概念。\n",
    "<br>\n",
    "**隨機變量與事件的聯繫與區別**\n",
    "<br>\n",
    "小結 1 中對著練歌概念的聯繫進行了非常詳細的描述。隨機變量實際上只是事件的另一種表達方式，這種表達方式更加的形式化和符號化，也更佳便於理解以及進行邏輯運算。不同的事件，其實就是隨機變量不同取值的組合。在陈希孺先生的書中，有一個很好的例子來說明這兩者的區別：<br>\n",
    "> 對於隨機試驗，我們所關心的往往是與所研究的特定問題有關的某個或某些變量，而這些量就是隨機變量。當然，有事我們所關心的是某個或某些特定的隨機時間。例如，在特定一群人中，年收入在萬元以上的高收入者，以及年收入在$3000$元以下的低收入者，各自比率如何？者看上去是兩個孤立的事件。可是當我們引入一個隨機變量$X$： \n",
    "> \n",
    "> <br>\n",
    "> <center> $X = $ 隨機抽出一個人其年收入</center>\n",
    "> <br>\n",
    "> \n",
    ">則$X$是我們關心的隨機變量。上述兩個事件可以分表表示為$\\{X > 10000\\}$或$\\{X < 3000\\}$。這就看出：**隨機事件**這個概念實際上包容在**隨機變量**這個更廣的概念之中。也就是說，隨機事件是靜態的觀點來研究隨機現象，而隨機變量則是一種動態的觀點。「概率論能從計算一些孤立事件的概率發展成為一個更高的理論體系，其根本概念就是隨機變量\n",
    "\n",
    "*這段話，非常清楚的解釋了隨機變量與事件的區別：就跟變量和常量之間的區別那樣*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 隨機變量的分類（The Classification of the Random Variable）\n",
    "\n",
    "**隨機變量從其可能的取值的性質分為兩大類：離散型隨機變量（Discrete Random Variable）和連續性隨機變量（Continuous Random Variable）**<br>\n",
    "##### 離散型隨機變量（Discrete Random Variable）\n",
    "\n",
    "離散型隨機變量的取值在整個實數軸上是有間隔的，要麼只有有限個取值，要麼就是無限可數。<br>\n",
    "如下圖："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1.   2.   3.   4.   5.   6.   7.   8.   9.  10.  11.  12.  13.  14.  15.\n",
      "  16.  17.]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11681f588>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy import stats\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def poisson_pmf(mu=3):\n",
    "    \n",
    "    poisson_dis = stats.poisson(mu)\n",
    "    x = np.arange(poisson_dis.ppf(0.001), poisson_dis.ppf(0.999))\n",
    "    print(x)\n",
    "    \n",
    "    fig, ax = plt.subplots(1, 1)\n",
    "    ax.plot(x, poisson_dis.pmf(x), 'bo', ms=8, label='poisson pmf')\n",
    "    ax.vlines(x, 0, poisson_dis.pmf(x), colors='b', lw=5, alpha=0.5)\n",
    "    ax.legend(loc='best', frameon=False)\n",
    "    plt.ylabel('Probability')\n",
    "    plt.title('PMF of poisson distribution(mu={}) - plot three'.format(mu))\n",
    "    plt.show()\n",
    " \n",
    "poisson_pmf(mu=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  4.   5.   6.   7.   8.   9.  10.  11.  12.  13.  14.  15.  16.  17.  18.]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1168b1470>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def binom_pmf(n=1, p=0.1):\n",
    "    binom_dis = stats.binom(n, p)\n",
    "    x = np.arange(binom_dis.ppf(0.0001), binom_dis.ppf(0.9999))\n",
    "    print(x)  \n",
    "    \n",
    "    fig, ax = plt.subplots(1, 1)\n",
    "    ax.plot(x, binom_dis.pmf(x), 'bo', label='binom pmf')\n",
    "    ax.vlines(x, 0, binom_dis.pmf(x), colors='b', lw=5, alpha=0.5)\n",
    "    ax.legend(loc='best', frameon=False)\n",
    "    plt.ylabel('Probability')\n",
    "    plt.title('PMF of binomial distribution(n={}, p={}) - plot four'.format(n, p))\n",
    "    \n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "binom_pmf(n=20, p=0.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Plot three 是 Poisson Distribution\n",
    "* Plot four 是 Binomal Distribution\n",
    "\n",
    "常見的**離散型隨機變量**包括以下這幾種：<br>\n",
    "\n",
    "* 0-1分佈（Bernoulli Distribution）\n",
    "* 二項分布（Binomial Distribution）\n",
    "* 幾何分佈（Geometric Distribution）\n",
    "* 泊松分佈（Poisson Distribution）\n",
    "* 超幾何分佈（Hyper-geometric Distribution）\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 連續型隨機變量（Continuous Random Variable）\n",
    "\n",
    "連續型隨機變量的取值要麼包括了整個實數集$(-\\infty, \\infty)$，要麼在一個區間內連續，總之，這一類的隨機變量的可能取值要比離散型隨機變量的取值多得多，個數是無窮不可數的。<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**常見的連續型隨機變量包括以下幾種**：<br>\n",
    "\n",
    "* 均勻分布\n",
    "* 指數分佈\n",
    "* 正太分佈（$\\gamma$分佈， $\\beta$分佈，$\\chi^2$分佈等）\n",
    "\n",
    "##### 概率密度函數的性質\n",
    "\n",
    "所有的概率密度函數$f(x)$都滿足一下的兩條性質；所有滿足下面兩條性質的一元函數也都可以作為概率密度函數。<br>\n",
    "$f(x) \\geq 0$，以及$\\int_{-\\infty}^{+\\infty}f(x)dx = 1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 隨機變量的基本性質\n",
    "\n",
    "隨機變量最主要的性質是其所有可能取到的這些值的取值規律，即取到的概率大小。如果我們把一個隨機變量的所有可能的取值的規律都研究透徹了，那麼這個隨機變量也就研究透徹了。隨機案變量的性質只要有兩類：一類是大而全的性質，這類性質可以詳細描述所有可能取值的概率，律如**累積分佈函數（Cumulative Distribution Funtion）**和**概率密度函數（Probability Density Function）**；另一類是找到該隨機變量的一些特徵或者代表值，例如隨機變量的方差或者期望等數字特徵。常見的隨機變量的性質如下表：\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|    name    | 解釋 |\n",
    "| :---: | :---: |\n",
    "| CDF: Cumulative Distribution Function |  連續型和離散型隨機變量都有，一般以$F(X)$表示 |\n",
    "| PDF: Probability Density Function    |  連續型隨機變量在各點的取值規律，用$f(x)$表示 |\n",
    "| PDF: Probability Density Function    |  連續型隨機變量在各點的取值規律，用$f(x)$表示 |\n",
    "| PMF: Probability Mass Function    |  離散型型隨機變量在各特定取值上的概率 |\n",
    "| RVS: Random Variate Sample    |  從一個給定分佈取樣 |\n",
    "| PPF: Percentile Point Function  |  CDF 的反函數 |\n",
    "| IQR: Inter Quartile Range   |  $25%$分位數與$75%$ 分位數之差 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*PDF 只有**連續型隨機變量**才有， PMF 只有**離散型隨機變量**才有；一個分佈的 CDF 求導等於 PDF， 一個分佈的 PDF 積分後就是 CDF*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 一維離散型隨機變量及其 Python 實現\n",
    "\n",
    "上一小節，對隨機變量做了一個概述，這一節主要紀錄以為離散變量以及關於他們的一些性質。對於概率論與數理統計方面的計算以及可視化，主要的`pyhton`包有`scipy`，`numpy`和`matplotlib`等。<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy import stats\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`scipy` 是 `python` 中使用最為廣泛的科學計算工具包，在加上`numpy`和`matplotlib`，基本可以處理大多數的計算和作圖任務。下面是`wikipedia`對`scipy`的介紹：<br>\n",
    "\n",
    "> SciPy是一个开源的Python算法库和数学工具包。SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。与其功能相类似的软件还有MATLAB、GNU Octave和Scilab。SciPy目前在BSD许可证下发布。它的开发由Enthought资助。\n",
    "\n",
    "我們使用的是 `scipy`中的 `stats`模塊，這個模塊包歡樂概率論以及統計相關的函數。\n",
    "相關函數可以查詢：<a href=\"https://docs.scipy.org/doc/scipy/reference/tutorial/stats.html\"> scipy stats</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  伯努利分佈（Bernoulli Distribution）\n",
    "\n",
    "又名兩點分佈或者$0-1$分佈，是一個離散型概率分佈。若伯努利試驗成功，則伯努利隨機變量取值為$1$，如果失敗則取值為$0$。記其成功概率為$p(0\\leq p \\leq 1)$，失敗概率為：$q = 1-p$。其概率質量函數（PMF） 為：<br>\n",
    "<center>\n",
    "    $\\begin{equation}     \\nonumber P_X(x) = \\left\\{     \\begin{array}{l l}     p& \\quad \\text{for  } x=1\\\\     1-p & \\quad \\text{ for } x=0\\\\     0  & \\quad \\text{ otherwise }     \\end{array} \\right. \\end{equation}$\n",
    "    </center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x68586c90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.stats import bernoulli\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "\n",
    "p = 0.8\n",
    "x = np.linspace(0,1)\n",
    "\n",
    "plt.plot(x,bernoulli.pmf(x,p),'o-',label='bernoulli pmf')\n",
    "\n",
    "plt.title('bernoulli pmf')\n",
    "plt.xlim(-0.1,1.1)\n",
    "plt.ylim(0,1)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "伯努利分佈只有一個參數$p$，記做$X ~ Bernuolli(p)$，或$X ~ B(1,p)$，讀做$X$服從參數為$p$的伯努利分佈。伯努利分佈適合於試驗結果只有兩種可能的單次試驗。例如拋一次硬幣，其結果只有正面或者反面兩種可能；一次產品質量檢測，結果只有合格還是不合格這兩種可能。<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x68640dd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.stats as stats\n",
    "from scipy.stats import bernoulli\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def bernoulli_pmf(p=0.0):\n",
    "\n",
    "    ber_dist = stats.bernoulli(p)\n",
    "    x = [0, 1]\n",
    "    x_name = ['0', '1']\n",
    "    pmf = [ber_dist.pmf(x[0]), ber_dist.pmf(x[1])]\n",
    "    plt.bar(x, pmf, width=0.15)\n",
    "    plt.xticks(x, x_name)\n",
    "    plt.ylabel('Probability')\n",
    "    plt.title('PMF of bernoulli distribution')\n",
    "    plt.show()\n",
    "\n",
    "bernoulli_pmf(p=0.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面兩幅圖都是表示伯努利分佈的 PMF；我們為了得到比較準確的某個服從伯努利分佈的隨機變量的期望，需要大量重複伯努利試驗，例如重複$n$次，然後利用$\\frac{正面朝上的次數}{n}$來估計$p$值，當我們重複$n$次以後，這就變成了二項分布，就是下面會提到的**二項分布**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 二项分布（Binomial Distribution）\n",
    "\n",
    "二項分布是指$n$個獨立的是/非試驗中成功的次數的離散概率分佈，其中每次試驗的成功概率為$p$。這樣的單詞成功/失敗試驗又稱為伯努利試驗。實際上，當$n = 1$時，二項分布就是伯努利分佈。二項分布時顯著性差異的二項試驗的基礎。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114dda828>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.stats as stats\n",
    "def binom_pmf(n=1, p=0.1):\n",
    "\n",
    "    binom_dis = stats.binom(n, p) \n",
    "    x = np.arange(binom_dis.ppf(0.0001), binom_dis.ppf(0.9999))\n",
    "    #print(x)  # [ 0.  1.  2.  3.  4.]\n",
    "    fig, ax = plt.subplots(1, 1)\n",
    "    ax.plot(x, binom_dis.pmf(x), 'bo',label='binom pmf')\n",
    "    ax.vlines(x, 0, binom_dis.pmf(x), colors='b', lw=5, alpha=0.5)\n",
    "    ax.legend(loc='best', frameon=False)\n",
    "    plt.ylabel('Probability')\n",
    "    plt.title('PMF of binomial distribution(n={}, p={})'.format(n, p))\n",
    "    plt.show()\n",
    "\n",
    "binom_pmf(n=20, p=0.6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 二項分布和其他分佈的關係\n",
    "\n",
    "1. 二項分布的和<br>\n",
    "    如果$X~B(n,p)$ 和$Y~B(n,p)$，且$X$和$Y$相互獨立，那麼$X + Y$ 也服從二項分佈：\n",
    "    $X + Y～B（n+m, p)$\n",
    "    \n",
    "2. 伯努利分佈<br>\n",
    "    二項分布就是$n$重伯努利試驗\n",
    "    \n",
    "3. 泊松分佈<br>\n",
    "   泊松分佈實際上可以通過二項分布推導出來，當$n$很大，$p$很小的時候，我們可以通過極限\n",
    "   去證明（證明見下方）\n",
    "   \n",
    "<br> 我們首先先畫圖來看，當$n = 100，p = 0.1$時"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11504b320>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "binom_pmf(n=1000000,p=0.00001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x114fd8630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# poisson_distribution_PMF\n",
    "def poisson_pmf(mu=1):\n",
    "   \n",
    "    poisson_dis = stats.poisson(mu)\n",
    "    x = np.arange(poisson_dis.ppf(0.001), poisson_dis.ppf(0.999))\n",
    "    #print(x)\n",
    "    fig, ax = plt.subplots(1, 1)\n",
    "    ax.plot(x, poisson_dis.pmf(x), 'bo', ms=8, label='poisson pmf')\n",
    "    ax.vlines(x, 0, poisson_dis.pmf(x), colors='b', lw=5, alpha=0.5)\n",
    "    ax.legend(loc='best', frameon=False)\n",
    "    plt.ylabel('Probability')\n",
    "    plt.title('PMF of poisson distribution(mu={})'.format(mu))\n",
    "    plt.show()\n",
    "\n",
    "poisson_pmf(mu=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由圖可得：兩者近似相等；下面是數學證明：\n",
    "\n",
    "Let $X$ be as described,\n",
    "Let $ k \\geq 0$ be fixed, we write $p = \\frac{\\lambda}{n}$ and suppose \n",
    "that $n$ is large.<br>\n",
    "Then: <br>\n",
    "\n",
    "<center>\n",
    "    $\\begin{align*}\n",
    "    Pr(X = k) &=  \\binom n k p^k \\left({1 - p}\\right)^{n-k} \\\\& \\simeq \\frac {n^k} {k!} \\left({\\frac \\lambda n}\\right)^k \\left({1 - \\frac \\lambda n}\\right)^n \\left({1 - \\frac \\lambda n}\\right)^{-k} \\\\ &= \\frac 1 {k!} \\lambda^k \\left({1 + \\frac {-\\lambda} n}\\right)^n \\left({1 - \\frac \\lambda n}\\right)^{-k} \\\\ &=  \\frac 1 {k!} \\lambda^k \\left({1 + \\frac {-\\lambda} n}\\right)^n \\\\ &\\simeq \\frac{1}{k}\\lambda^k e^{-\\lambda} \\end{align*}$\n",
    "   </center>\n",
    "   \n",
    "\n",
    "when $n \\gg k$ it's a reasonable approximation for $\\binom n k $, as $ 1-p = (1 - \\frac{\\lambda}{n})$ is very close to $1$. Hence the result.\n",
    "<br>\n",
    "<br>\n",
    "**Comment:**\n",
    "Okay wise guy, exactly what constitutes \"very large\", \"very small\", and \"of a reasonable size\"?\n",
    "Well, if $n = 10^6$ and $p = 10^{-5}$, we have np = 10 = \\lambda$\n",
    "That's the sort of order of magnitude we're talking about here.\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 泊松分佈（Poisson Distribution）\n",
    "\n",
    "泊松分佈有一個參數$\\lambda$（或$\\mu$），表示單位事件內隨機事件的平均發生次數，其 PMF 表示為：<br>\n",
    "\n",
    "<center>\n",
    "    $\\begin{equation}\\nonumber P_X(k) = \\left\\{\\begin{array}{l l}\\frac{e^{-\\lambda} \\lambda^k}{k!}& \\quad \\text{for  } k \\in R_X\\\\       0  & \\quad \\text{ otherwise} \\end{array} \\right.             \\end{equation}$\n",
    "</center>\n",
    "<br>\n",
    "\n",
    "以上表示單位時間上的泊松分佈，即$t = 1$，如果表示時間$t$上的泊松分佈，則需要將$\\lambda$乘以$t$ $\\Rightarrow\\lambda t$\n",
    "<br>\n",
    "\n",
    "一個隨機變量$X$服從參數為$\\lambda$的柏松分佈，記做$X～Poisson(\\lambda)$，或$X～P(\\lambda)$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "泊松分佈適合於描述單位時間內隨機時間發生的次數的概率分佈。如，某一服務設施在一定時間內收到的服務請求的次數，電話交換機接到胡椒的次數，機器出現的故障數，DNA序列的變異數等等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 一維連續型隨機變量及其 Python 實現\n",
    "\n",
    "上一小節總結了幾種離散型隨機變量，這個小節總結連續型隨機變量。離散型隨機變量的可能取值為有限多個或者無限可數，而連續型隨機變量的可能取值則為一段連續的區域或者整個實數軸，是不可數的。最常見的連續型隨機變量有三種：均勻分布、指數分佈和正太分佈。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 均勻分佈（Uniform Distribution）\n",
    "\n",
    "如果連續型隨機變量$X$具有如下的概率目睹函數，則稱$X$服從$[a,b]$上的菊允分佈，記做$X～U[a,b]$<br>\n",
    "<center>\n",
    "    $\\begin{equation}              \\nonumber f_X(x) = \\left\\{               \\begin{array}{l l}                 \\frac{1}{b-a} & \\quad  a < x < b\\\\                 0 & \\quad x < a \\textrm{ or } x > b               \\end{array} \\right.             \\end{equation}$\n",
    "</center>\n",
    "<br>\n",
    "\n",
    "均勻分佈具有等可能性，也就是說服從$U(a,b)$上的均勻分佈的隨機變量$X$落入$(a,b)$中國年的任意子區間的概率只與其取件長度有關，與取件所處的位置無關。<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由於是均勻分佈的概率函數是一個常數，因此，其累積分佈函數是一條直線，隨著其取值在定義域內增加，累積分佈函數值均勻增加。\n",
    "<br>\n",
    "\n",
    "<center>\n",
    "    $\\begin{equation} \t\t\t\t\t\t  \\hspace{70pt}                           F_X(x)  = \\left\\{                           \\begin{array}{l l}                             0 & \\quad \\textrm{for } x < a \\\\                             \\frac{x-a}{b-a} & \\quad \\textrm{for }a \\leq x \\leq b\\\\                             1 & \\quad \\textrm{for } x > b                           \\end{array} \\right. \t\t\t\t\t\t  \\hspace{70pt}                           \\end{equation}$\n",
    "</center>\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x116964d68>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.stats import uniform\n",
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "\n",
    "x = np.linspace(-2, 2)\n",
    "ax.plot(x, uniform.cdf(x),'r-', lw=5, alpha=0.6)\n",
    "plt.title(\"CDF of uniform distribution\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "均勻分佈主要可以用在：\n",
    "* 設通過某站的汽車10分鐘一輛，則乘客候車時間$X$，在$[0,10]$上服從均勻分佈；\n",
    "* 某電台每20分鐘發一個信號，我們隨手打開收音機，等待的時間$X$在$[0,20]$上服從均勻分佈 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.004  4.     5.996]\n",
      "True\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x116ae3160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def uniform_distribution(loc=0, scale=1):\n",
    "    \"\"\"\n",
    "    均匀分布，在实际的定义中有两个参数，分布定义域区间的起点和终点[a, b]\n",
    "    :param loc: 该分布的起点, 相当于a\n",
    "    :param scale: 区间长度, 相当于 b-a\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    uniform_dis = stats.uniform(loc=loc, scale=scale)\n",
    "    x = np.linspace(uniform_dis.ppf(0.01),\n",
    "                    uniform_dis.ppf(0.99), 100)\n",
    "    fig, ax = plt.subplots(1, 1)\n",
    "\n",
    "    # 直接传入参数\n",
    "    ax.plot(x, stats.uniform.pdf(x, loc=2, scale=4), 'r-',\n",
    "            lw=5, alpha=0.6, label='uniform pdf')\n",
    "\n",
    "    # 从冻结的均匀分布取值\n",
    "    ax.plot(x, uniform_dis.pdf(x), 'k-',\n",
    "            lw=2, label='frozen pdf')\n",
    "\n",
    "    # 计算ppf分别等于0.001, 0.5, 0.999时的x值\n",
    "    vals = uniform_dis.ppf([0.001, 0.5, 0.999])\n",
    "    print(vals)  # [ 2.004  4.     5.996]\n",
    "\n",
    "    # Check accuracy of cdf and ppf\n",
    "    print(np.allclose([0.001, 0.5, 0.999], uniform_dis.cdf(vals)))  # Ture\n",
    "\n",
    "    r = uniform_dis.rvs(size=10000)\n",
    "    ax.hist(r, normed=True, histtype='stepfilled', alpha=0.2)\n",
    "    plt.ylabel('Probability')\n",
    "    plt.title(r'PDF of Unif({}, {})'.format(loc, loc+scale))\n",
    "    ax.legend(loc='best', frameon=False)\n",
    "    plt.show()\n",
    "\n",
    "uniform_distribution(loc=2, scale=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "從定義式中可以看出，定義一個均勻分佈需要兩個參數：定義域的起點$a$和終點$b$，但是在`Python`中是`localtion`是`scale`，分別表示起點和區間長度: <a href=\"https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.uniform.html\">scripy.stats.uniform</a><br>\n",
    "\n",
    "上面的代碼採用了兩種方式$\\Rightarrow$直接傳入參數和先凍結了一個分佈，然後畫出均勻分佈的概率分佈函數。此外還從該分佈中選取了10000個值做直方圖。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上圖是一個均勻分佈：$U(2,6)$的概率密度函數曲線"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 指數分佈（Exponentinal Distribution）\n",
    "\n",
    "在概率論和統計學中，指數分佈（Exponential Distribution）是一種連續型的概率分佈。可以用來表示獨立隨機時間發生的時間間隔，比如旅客進入機場的時間間隔，打進客服中心電話的時間間隔、中文維基百科新條目出現的時間等等。其實，指數分佈和離散型的泊松分佈有很大關係。泊松分佈表示的是單位時間（或單位面積）內隨機時間的平均發生次數，指數分佈則可以用來表示獨立隨機事件發生的時間間隔。由於發生次數之能事自然數，所以泊松分佈很自然就是離散型的隨機變量；而時間間隔則可以是任意的實數，因此其定義域為：$(0, +\\infty)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果一個隨機變量$X$的概率密度函數滿足以下形式，就稱$X$為服從參數$\\lambda$的指數分佈（Exponential\n",
    "Distribution），記做$X～E(\\lambda)$或$X～Exp(\\lambda)$<br>\n",
    "\n",
    "指數函數只有一個參數$\\lambda$，且$\\lambda > 0$\n",
    "<br>\n",
    "<center>\n",
    "    $\\begin{equation}              \\nonumber f_X(x) = \\left\\{               \\begin{array}{l l}                 \\lambda e^{-\\lambda x} & \\quad  x > 0\\\\                 0 & \\quad \\textrm{otherwise}               \\end{array} \\right.             \\end{equation}$\n",
    "</center>\n",
    "<br>\n",
    "\n",
    "##### 主要用途：\n",
    "\n",
    "* 表示獨立隨機案時間發生的時間間隔；\n",
    "* 在排隊輪中，一個顧客接受服務的時間段也可以用指數分佈來近似；\n",
    "* 無記憶性的現象（連續時間）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 性質\n",
    "\n",
    "指數分佈的一個顯著的特點就是具有無記憶性。例如如果排隊的顧客接受服務的時間長短服從指數分佈，那麼無論你已經排了多久的隊伍，在排$t$分鐘的概率始終是相同的。\n",
    "<br>\n",
    "\n",
    "用公式表達則為：<br>\n",
    "<center>\n",
    "    $P(X \\geq s + t | X \\geq s) = P(X \\geq t) \\text{  for all  } s,t > 0$\n",
    "</center>\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  2.00100067e-03   1.38629436e+00   1.38155106e+01]\n",
      "True\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x717dc6d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as stats\n",
    "\n",
    "def exponential_dis(loc=0, scale=1.0):\n",
    "    \"\"\"\n",
    "    指数分布，exponential continuous random variable\n",
    "    按照定义，指数分布只有一个参数lambda，这里的scale = 1/lambda\n",
    "    :param loc: 定义域的左端点，相当于将整体分布沿x轴平移loc\n",
    "    :param scale: lambda的倒数，loc + scale表示该分布的均值，scale^2表示该分布的方差\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    exp_dis = stats.expon(loc=loc, scale=scale)\n",
    "    x = np.linspace(exp_dis.ppf(0.000001),\n",
    "                    exp_dis.ppf(0.999999), 100)\n",
    "    fig, ax = plt.subplots(1, 1)\n",
    "\n",
    "    # 直接传入参数\n",
    "    ax.plot(x, stats.expon.pdf(x, loc=loc, scale=scale), 'r-',\n",
    "            lw=5, alpha=0.6, label='uniform pdf')\n",
    "\n",
    "    # 从冻结的均匀分布取值\n",
    "    ax.plot(x, exp_dis.pdf(x), 'k-',\n",
    "            lw=2, label='frozen pdf')\n",
    "\n",
    "    # 计算ppf分别等于0.001, 0.5, 0.999时的x值\n",
    "    vals = exp_dis.ppf([0.001, 0.5, 0.999])\n",
    "    print(vals)  \n",
    "\n",
    "    # Check accuracy of cdf and ppf\n",
    "    print(np.allclose([0.001, 0.5, 0.999], exp_dis.cdf(vals)))\n",
    "\n",
    "    r = exp_dis.rvs(size=10000)\n",
    "    ax.hist(r, normed=True, histtype='stepfilled', alpha=0.2)\n",
    "    plt.ylabel('Probability')\n",
    "    plt.title(r'PDF of Exp(0.5)')\n",
    "    ax.legend(loc='best', frameon=False)\n",
    "    plt.show()\n",
    "\n",
    "exponential_dis(loc=0, scale=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上圖是，$Exp(0,5)$的概率分佈函數圖<br>\n",
    "\n",
    "下面是對不同參數的指數分佈的概率分佈函數圖的比較："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x687fc9d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def diff_exp_dis():\n",
    "    \"\"\"\n",
    "    不同参数下的指数分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    exp_dis_0_5 = stats.expon(scale=0.5)\n",
    "    exp_dis_1 = stats.expon(scale=1)\n",
    "    exp_dis_2 = stats.expon(scale=2)\n",
    "\n",
    "    x1 = np.linspace(exp_dis_0_5.ppf(0.001), exp_dis_0_5.ppf(0.9999), 100)\n",
    "    x2 = np.linspace(exp_dis_1.ppf(0.001), exp_dis_1.ppf(0.999), 100)\n",
    "    x3 = np.linspace(exp_dis_2.ppf(0.001), exp_dis_2.ppf(0.99), 100)\n",
    "    fig, ax = plt.subplots(1, 1)\n",
    "    ax.plot(x1, exp_dis_0_5.pdf(x1), 'b-', lw=2, label=r'lambda = 2')\n",
    "    ax.plot(x2, exp_dis_1.pdf(x2), 'g-', lw=2, label='lambda = 1')\n",
    "    ax.plot(x3, exp_dis_2.pdf(x3), 'r-', lw=2, label='lambda = 0.5')\n",
    "    plt.ylabel('Probability')\n",
    "    plt.title(r'PDF of Exponential Distribution')\n",
    "    ax.legend(loc='best', frameon=False)\n",
    "    plt.show()\n",
    "\n",
    "diff_exp_dis()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 正態分佈（Normal Distribution）\n",
    "\n",
    "正態分佈，又名高斯分佈（Gaussian Distribution），是一種非常常見的連續概率分佈，經常用在自然和社會科學中表示一種不明的隨機變量。由於中心極限定理的存在，正太分佈也是所有分佈中應用最廣泛的分佈。<br>\n",
    "\n",
    "##### 定義：\n",
    "\n",
    "若隨機變量$X$的概率密度符合以下形式，就稱$X$服從參數為$\\mu, \\sigma$的正態分佈，記做：$X～N(\\mu,\\sigma^2)$.\n",
    "<br>\n",
    "<center>\n",
    "    $f_X (x) = \\frac{1}{\\sqrt{2 \\pi } \\sigma} \\exp \\left\\{-\\frac{(x - \\mu)^2}{2 \\sigma^2} \\right\\}, \\hspace{20pt} \\textrm{for all } x \\in \\mathbb{R}.$\n",
    "</center>\n",
    "<br>\n",
    "\n",
    "如果上式公式中$\\mu = 0, \\sigma = 1$，就叫做標準正態分佈（Standard Normal Distribution），一般記做$Z～N(0,1)$<br>\n",
    "\n",
    "由於標準正態分佈在統計學中的重要地位，它的累積分佈函數（CDF）有一個專門的表示符號：$\\Phi$，一般在統計相關的書籍附錄中的“標準正太分佈函數值表”就是該值與隨機變量的取值之間的對應關係。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x6885bb50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.stats as stats\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plot\n",
    "\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "x = np.linspace(-3,3)\n",
    "y = stats.norm.cdf(x, loc=0, scale=1)\n",
    "y1 = stats.norm.pdf(x, loc=0, scale=1)\n",
    "ax.plot(x,y,'-',label='cdf of standard norm')\n",
    "ax.plot(x,y1,'-',label='pdf of standard norm')\n",
    "ax.legend( loc='best',frameon=False)\n",
    "\n",
    "plt.title(r'Standard Normal Distribution')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 正態分佈兩個參數含義：\n",
    "* 當固定$\\sigma$，改變$\\mu$時，$f(x)$圖形的形狀不變，只是沿著$x$軸做平移變換，因此$\\mu$被稱為位置參數（決定了（對稱軸的位置）；\n",
    "*當固定$\\mu$，改變$\\sigma$時，$f(x)$圖形的對稱軸不變，形狀改變，$\\sigma$越小，圖形越高越瘦;$\\sigma$越大，圖形越矮越胖，因此$\\sigma$被稱為尺度參數（決定曲線的分散程度）<br>\n",
    "\n",
    "下面是示例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x6865e790>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.stats as stats\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plot\n",
    "\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "x = np.linspace(-5,5)\n",
    "y = stats.norm.pdf(x, loc=0, scale=1)\n",
    "y1 = stats.norm.pdf(x, loc=2, scale=1)\n",
    "ax.plot(x,y,'-',label='pdf of norm with mu = 0')\n",
    "ax.plot(x,y1,'-',label='pdf of norm with mu = 2')\n",
    "ax.legend(loc='best',frameon=True)\n",
    "\n",
    "plt.title(r'Normal Distribution')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x6869a790>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.stats as stats\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plot\n",
    "\n",
    "fig, ax = plt.subplots(1, 1)\n",
    "x = np.linspace(-5,5)\n",
    "y = stats.norm.pdf(x, loc=0, scale=1)\n",
    "y1 = stats.norm.pdf(x, loc=0, scale=2)\n",
    "ax.plot(x,y,'-',label='pdf of norm with sigma = 1')\n",
    "ax.plot(x,y1,'-',label='pdf of norm with sigma = 2')\n",
    "ax.legend(loc='best',frameon=True)\n",
    "\n",
    "plt.title(r'Normal Distribution')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 性質：\n",
    "\n",
    "* $f(x)$關於$x = \\mu$對稱；\n",
    "* 當$x \\leq \\mu$時，$f(x)$ 時嚴格單調遞增函數；\n",
    "* $f_max = f(\\mu) = \\frac{1}{\\sqrt{2\\pi}\\sigma}$;\n",
    "* 當$X～N(\\mu,\\sigma^2)$時，$\\frac{X - \\mu}{\\sigma} \\sim N(0, 1)$\n",
    "<br>\n",
    "\n",
    "*利用第四點，我們在計算一般的正態分佈時，可以轉化成標準正態分佈進行計算*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x6863ae50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def diff_normal_dis():\n",
    "\n",
    "    norm_dis_0 = stats.norm(0, 1)  # 标准正态分布\n",
    "    norm_dis_1 = stats.norm(0, 0.5)\n",
    "    norm_dis_2 = stats.norm(0, 2)\n",
    "    norm_dis_3 = stats.norm(2, 2)\n",
    "\n",
    "    x0 = np.linspace(norm_dis_0.ppf(1e-8), norm_dis_0.ppf(0.99999999), 1000)\n",
    "    x1 = np.linspace(norm_dis_1.ppf(1e-10), norm_dis_1.ppf(0.9999999999), 1000)\n",
    "    x2 = np.linspace(norm_dis_2.ppf(1e-6), norm_dis_2.ppf(0.999999), 1000)\n",
    "    x3 = np.linspace(norm_dis_3.ppf(1e-6), norm_dis_3.ppf(0.999999), 1000)\n",
    "    fig, ax = plt.subplots(1, 1)\n",
    "    ax.plot(x0, norm_dis_0.pdf(x0), 'r-', lw=2, label=r'miu=0, sigma=1')\n",
    "    ax.plot(x1, norm_dis_1.pdf(x1), 'b-', lw=2, label=r'miu=0, sigma=0.5')\n",
    "    ax.plot(x2, norm_dis_2.pdf(x2), 'g-', lw=2, label=r'miu=0, sigma=2')\n",
    "    ax.plot(x3, norm_dis_3.pdf(x3), 'y-', lw=2, label=r'miu=2, sigma=2')\n",
    "    plt.ylabel('Probability')\n",
    "    plt.title(r'PDF of Normal Distribution')\n",
    "    ax.legend(loc='best', frameon=False)\n",
    "    plt.show()\n",
    "\n",
    "diff_normal_dis()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 隨機變量的數字特徵（Numerical Characteristic）\n",
    "\n",
    "如果說一個隨機變量的分佈函數（累積分佈函數或概率密度分佈）是對隨機變量最完整，最具體的描述，那麼隨機變量的數字特徵就是對該隨機變量特徵的描述。分佈函數就如同一個人的全身像，而數字特徵就像一個人的局部特寫。\n",
    "\n",
    "#### 常見的數字特徵：\n",
    "\n",
    "* 數學期望（Expectation）\n",
    "* 方差（Variance）\n",
    "* 矩（Moments）\n",
    "* 協方差和相關係數（Covariance and Correlative Coefficient ）\n",
    "\n",
    "前面三個數字特徵都是耽擱隨機變量自身的特徵，第四個數字特徵則是表示兩個隨機變量之間的關係，其他數學特種還有中位數，眾數等等"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 數學期望（Matematical Expectation）\n",
    "\n",
    "一個隨機變量$X$的數學期望，簡稱期望，也叫做均值（Mean），記做E(X)。常見於隨機變量的定義中，都直接或間接包含了“期望”這個參數，該參數一般於分佈在座標軸上的位置有關。期望與我們平時說的平均值不多，體現的是隨機變量中的“大碩鼠”的取值情況或趨勢。\n",
    "<br>\n",
    "\n",
    "在計算中，隨機變量$X$的平均值E(X)並不等於一個具體樣本集$x$的均值E(x)$\\Rightarrow$計算一個具體樣本集的均值時，是將所有的值求和然後除以樣本個數，因為此時的$x$已經是一個具體的數列，而不再具有隨機性$\\Rightarrow$隨機變量$X$的均值是加權平均數。\n",
    "<br>\n",
    "\n",
    "例如，一個離散型隨機變量$X$的概率質量分佈列如下：\n",
    "<br>\n",
    "\n",
    "|X|0|1|2|3|4|\n",
    "|------|----|----|----|----|----|\n",
    "|P(X=x)|0.15|0.30|0.25|0.20|0.10|\n",
    "<br>\n",
    "\n",
    "那麼，根據定義，我們可以算出：$E(X) = \\displaystyle \\sum_{ i = 1 }^{ n } x_i p_i = 0 \\times 0.15 + 1 \\times 0.3 + 2 \\times 0.25 + 3 \\times 0.2 + 4 \\times 0.1 = 1.8$；如果我們從該隨機變量中取1個樣本集$x_1 = 1，1，2，4，4$，那麼$E(x_1) = \\frac{1 + 1 + 2 + 4 + 4}{5} = 2.4$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，正是定義中對期望是否存在給出了明確的定義：在求離散型隨機變量的期望時，需要其和式構成的級數是收斂的；在連續型隨機變量時，也有類似的要求。一個典型的例子：連續型隨機變量「柯西分佈」因為不滿足此條件，所以不具有均值，具體解釋可以參考：<a href\"http://web.ipac.caltech.edu/staff/fmasci/home/mystats/CauchyVsGaussian.pdf\"> Comparing the Cauchy and Gaussian (Normal) density function</a> 和 <a href=\"https://stats.stackexchange.com/questions/36027/why-does-the-cauchy-distribution-have-no-mean\"> Why does the Cauchy distribution have no mean ? </a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 期望的性質：\n",
    "\n",
    "* 設$c$為一個常數，則$E(c) = c$;\n",
    "* 設$X$是一個隨機變量，$c$是常數，則$E(cX) = cE(X)$;\n",
    "* 設$X,Y$是兩個隨機變量，則有$E(X + Y) = E(X) + E(Y)$；<br>\n",
    "\n",
    "將上面三個性質結合起來，則有：$E(aX + bY + c) = aE(X) + bE(Y) + c$，可以推廣到任意有限個隨機變量線性組合的情況；\n",
    "\n",
    "* 設$X,Y$是相互獨立的兩個隨機變量，則有$E(XY) = E(X)E(Y)$，可以推廣到任意有限個相互獨立的隨機變量之積的情況。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 常見分佈的期望\n",
    "\n",
    "下面這些分佈的期望是指隨機變量的期望，而不是某個隨機變量抽樣得到的樣本集的期望。在離散隨機變量中，數學期望的物理意義是「一維離散質點系的重心坐標“，在連續型隨機變量中，數學期望的物理意義是「一維連續質點系的重心坐標”。\n",
    "<br>\n",
    "\n",
    "* 0-1 分佈：$X～B(1,p), E(X) = p$;\n",
    "* 二項分佈：$X～B(n,p), E(X) = np$;\n",
    "* 泊松分佈：$X～P(\\lambda), E(X) = \\lambda$;\n",
    "* 幾何分佈：$X～G(p), E(X) = \\frac{1}{p}$;\n",
    "* 均勻分佈：$X～N(a, b), E(X) = \\frac{a+b}{2}$;\n",
    "* 正態分佈：$X～N(\\mu, \\sigma^2), E(X) = \\mu$;\n",
    "* 指數分佈，$X～E(\\lambda), E(X) = \\frac{1}{\\lambda}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 樣本均值的計算\n",
    "\n",
    "在實際的應用中，我們一般都是已知某個分佈的一組樣本，需要求這組樣本的均值。在計算時，定義中的平均值時算術平均值；還有一種是計算幾何平均值，及所有樣本值相乘後開$N$次方，$N$為樣本數。\n",
    "<br> \n",
    "\n",
    "算術平均值和幾何平均值最大的區別在於：如果樣本中有$0$存在，幾何平均值就等於$0$；如果樣本中不包含$0$，通常算數平均值$\\geq$幾何平均值。下面是 $Python$的實現方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  5  6  7  8  9 10]\n",
      "5.5\n",
      "[  1.   2.   3.   4.   5.   6.   7.   8.   9.  10.  nan]\n",
      "nan\n",
      "5.5\n",
      "[ 1  2  3  4  5  6  7  8  9 10]\n",
      "4.52872868812\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy import stats\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "## 计算平均值\n",
    "x = np.arange(1, 11)\n",
    "print(x)  # [ 1  2  3  4  5  6  7  8  9 10]\n",
    "mean = np.mean(x)\n",
    "print(mean)  # 5.5\n",
    "\n",
    "# 对空值的处理，nan stands for 'Not-A-Number'\n",
    "x_with_nan = np.hstack((x, np.nan))\n",
    "print(x_with_nan)  # [  1.   2.   3.   4.   5.   6.   7.   8.   9.  10.  nan]\n",
    "mean2 = np.mean(x_with_nan)\n",
    "print(mean2)  # nan，直接计算没有结果\n",
    "mean3 = np.nanmean(x_with_nan)\n",
    "print(mean3)  # 5.5\n",
    "\n",
    "## 计算几何平均值\n",
    "x2 = np.arange(1, 11)\n",
    "print(x2)  # [ 1  2  3  4  5  6  7  8  9 10]\n",
    "geometric_mean = stats.gmean(x2)\n",
    "print(geometric_mean)  # 4.52872868812，几何平均值小于等于算数平均值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 方差（Variance）\n",
    "\n",
    "一個隨機變量$X$的方差，刻畫了$X$取值的波動性，是衡量該隨機變量取值分散程度的數字特徵。方差越大，就表示該隨機變量越分散；方差越小，表示該隨機變量越集中。在實際應用中，例如常見的「QC」問題，如果一個工廠的出場的合格評分方差大，說明了優質品和劣質品都比較多，**出品不穩定**；相反，如果方差比較小，說明了合格品比較多，優質品和劣質品較少，**出品穩定**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 性質：\n",
    "1. 設$c$為常數，則$Var(c) = 0$；\n",
    "2. 設$X$是一個隨機變量，$c$是常數，則$Var(cX) = c^2 Var(X)$；特例，$D(-X) = D(X)$；\n",
    "3. 設$X, Y$是兩個隨機變量，則有$Var(X + Y) = Var(X) + Var(Y) + 2\\cdot tail$，其中，$tail = E[X-E(X)][Y-E(Y)]$. 特別的，如果$X, Y$相互獨立，則$tail = 0$\n",
    "4. $Var(X) = 0 \\Leftrightarrow P(X = c) =1,$ 且$c = E(X)$ ;\n",
    "5. 當$X, Y$相互獨立時，$Var(XY) = Var(X)Var(Y) + Var(X)[E(Y)]^2 +Var(Y)[E(X)]^2$\n",
    "<br>\n",
    "\n",
    "還有一個常用的計算方差的公式：$D(X) = E(X^2) - [E(X)]^2$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 常見分佈的方差：\n",
    "\n",
    "* 0-1 分佈：$X～B(1,p), Var(X) = p(1-p)$;\n",
    "* 二項分佈：$X～B(n,p), Var(X) = np(1-p)$;\n",
    "* 泊松分佈：$X～P(\\lambda), Var(X) = \\lambda$;\n",
    "* 幾何分佈：$X～G(p), Var(X) = \\frac{1-p}{p^2}$;\n",
    "* 均勻分佈：$X～N(a, b), Var(X) = \\frac{(b-a)^2}{12}$;\n",
    "* 正態分佈：$X～N(\\mu, \\sigma^2), Var(X) = \\sigma^2, (\\sigma > 0)$;\n",
    "* 指數分佈，$X～E(\\lambda), Var(X) = \\frac{1}{\\lambda^2}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 樣本方差的計算\n",
    "\n",
    "就如同計算均值一樣，通常我們的計算都是從某個分佈中抽樣得到的一組樣本的方差，樣本方差一般使用$S^2$表示，按照方差的定義：\n",
    "<br>\n",
    "<center>\n",
    "    $Var(X) = E{[X - E(X)]^2} = \\frac{1}{n} \\displaystyle \\sum_{i=1}^{n}(X_i - \\bar{X})^2$\n",
    "</center>\n",
    "<br>\n",
    "\n",
    "其中：$\\bar{X} = E(X)$。如果直接用上面的公式計算$S^2$，等同於使用樣本的二階中心距。但是樣本的二階中心距並不是隨機變量$X$這個總體分佈的無偏估計，將上式中的$n$換成$n-1$就得到了樣本方差計算公式，這也是總體方差無偏估計。\n",
    "<br>\n",
    "<center>\n",
    "    $S^2 = \\frac{1}{n - 1} \\displaystyle \\sum_{i=1}^{n}(X_i - \\bar{X})^2$\n",
    "</center>\n",
    "<br>\n",
    "\n",
    "從直觀來說，由於樣本方差中多了一個約束條件 ——樣本的均值時固定的，$E(X) = \\bar{X} \\Rightarrow $如果已知$n-1$樣本，那麼根據均值可以直接計算出第$n$哥樣本的值，因此自由度比計算總體方差的時候減少了$1$個。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 7  8  9 10 11 12 13]\n",
      "4.0\n",
      "4.66666666667\n",
      "2.0 2.16024689947\n",
      "4.0 4.66666666667\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 参考\n",
    "# https://docs.scipy.org/doc/numpy/reference/generated/numpy.std.html\n",
    "# https://docs.scipy.org/doc/numpy/reference/generated/numpy.var.html\n",
    "\n",
    "\n",
    "data = np.arange(7, 14)\n",
    "print(data)  # [ 7  8  9 10 11 12 13]\n",
    "\n",
    "## 计算方差\n",
    "# 直接使用样本二阶中心距计算方差，分母为n\n",
    "var_n = np.var(data)  # 默认，ddof=0\n",
    "print(var_n) # 4.0\n",
    "# 使用总体方差的无偏估计计算方差，分母为n-1\n",
    "var_n_1 = np.var(data, ddof=1)  # 使用ddof设置自由度的偏移量\n",
    "print(var_n_1) # 4.67\n",
    "\n",
    "\n",
    "## 计算标准差\n",
    "std_n = np.std(data, ddof=0)\n",
    "std_n_minus_1 = np.std(data, ddof=1)  # 使用ddof设置自由度的偏移量\n",
    "print(std_n, std_n_minus_1)  # 2.0, 2.16\n",
    "print(std_n**2, std_n_minus_1**2)  # 4.0, 4.67"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 矩\n",
    "\n",
    "矩是一個非常廣泛的概念，期望和方差都是矩的特例。<br>\n",
    "\n",
    "##### 定義：\n",
    "\n",
    "* 若$E(X^k), k = 1, 2, \\dots $存在，則稱$E(X^k)$為$X$的$k$階原點矩，記做$\\alpha_k = E(X^k)$；\n",
    "* 若$E[X - E(X)]^k, k = 1, 2, \\dots$存在，則稱$E[X-E(X)]^k$為$X$的$k$階中心距，記做$\\beta_k = E[X-E(X)]^k$ \n",
    "\n",
    "根據定義，期望$E(X)$ 是1階原點矩，方差$D(X)$是2階中心距。需要注意的是，就跟上面提到的一樣，樣本的2屆中心距並不是總體方差的無偏估計，樣本方差$S^2$的時機計算公式中分母為$n-1$，而不是樣本2階中心距中的$n$。\n",
    "<br>\n",
    "\n",
    "**符號說明**：\n",
    "\n",
    "* 總體k阶原點矩：$α_k$;\n",
    "* 總體k阶中心矩：$β_k$;\n",
    "* 樣本k阶原點矩：$A_k$;\n",
    "* 樣本k阶中心矩：$B_k$;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 協方差（Covariance）\n",
    "\n",
    "上面介紹了幾種隨機變量的數字特徵都是描述耽擱隨機變量拘捕性質的量，協方擦好和相關係數則是用來度量兩個不同的隨機變量之間的相關程度。<br>\n",
    "\n",
    "##### 協方差\n",
    "\n",
    "如上面介紹方差的性質時，第(3)條提到的那樣：\n",
    "<br>\n",
    "\n",
    "設$X, Y$是兩個隨機變量，則有$ Var(X + Y) = Var(X) + Var(Y) + 2\\cdot tail$，其中，$tail = E[X - E(X)][Y - E(Y)].$ 特別的，若$X, Y$相互獨立，那麼$tial = 0$，那麼$tail$不等於$0$，就代表了這兩個隨機變量不相互獨立。$tail$就是$X$與$Y$的協方差。\n",
    "\n",
    "##### 定義：\n",
    "\n",
    "數值$E[X-E(Y)][Y-E(Y)]$為隨機變量$X$與$Y$的協方差，記做$Cov(X,Y)$，即：\n",
    "<br>\n",
    "<center>\n",
    "    $Cov(X, Y) = E{[X - E(X)][Y - E(Y)]}$\n",
    "</center>\n",
    "<br>\n",
    "\n",
    "此時，$Var(X + Y) = Var(X) + Var(Y) + 2Cov(X,Y)$，協方差$Cov(X, Y)$反映了隨機變量的$X$與$Y$的線性相關性： <br>\n",
    "\n",
    "* 當$Cov(X,Y0 > 0$時，稱$X$與$Y$正相關；\n",
    "* 當$Cov(X,Y0 < 0$時，稱$X$與$Y$負相關；\n",
    "* 當$Cov(X,Y0 = 0$時，稱$X$與$Y$無關；\n",
    "\n",
    "協方差的計算公式可以簡化成：$Cov(X,Y) = E(XY) - E(X)E(Y)$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 相關係數\n",
    "\n",
    "協方差時有量綱的數字特徵，為了消除其量綱的影響，引入了相關係數，在平時的數據分析中協方差很少出現，先港係數出現的頻率非常高。\n",
    "<br>\n",
    "<center>\n",
    "    $\\rho_{XY} = \\frac{Cov(X, Y)}{\\sqrt{D(X)D(Y)}}$\\\n",
    "</center>\n",
    "<br>\n",
    "\n",
    "稱為隨機變量$X$與$Y$的相關係數。\n",
    "\n",
    "##### 相關係數的性質\n",
    "\n",
    "* $|\\rho XY|\\leq 1$（相關係數的值位於區間[-1,1]）；\n",
    "* $|\\rho XY| = 1 \\Rightarrow$ 存在常數$a,b$使得$P(Y = a+bX)=1$. 特別的，$\\rho XY = 1$時，$b > 0$；$\\rho = 1$時，$b < 0$. 與協方差，相關係數也是用來表徵兩個隨機變量之間線性關係密切程度的特徵數，有時也稱為「線性相關係數」"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 樣本均值的期望和方差\n",
    "\n",
    "設隨機變量$X$的一組樣本為$x$，則樣本的矩陣$\\bar{x} = \\frac{1}{n} \\displaystyle \\sum_{i=1}^{n}x_i$。此時的樣本$x$與樣本均值$\\bar{x}$都是確定的數值，不具有隨機行。但是，如果我們卻了很多組樣本L：$x^{(1)}, x^{(2)}, ...$那麼這些樣本的均值$\\bar{x}^{(1)}, \\bar{x}^{(2)}, ...$就可以組成一個新的隨機變量，可以記做$\\bar{X}$，每一個樣本均值也可以看作從該隨機變量中抽樣所得。<br>\n",
    "\n",
    "樣本均值$\\bar{X}$這個隨機變量時隨機變量$X$的函數。根據期望和方差的定義，我們可以求出樣本均值的期望和方差。<br>\n",
    "假設隨機變量$X$的期望和方差分別是：$\\mu$和$\\sigma^2$\n",
    "\n",
    "* E($\\bar{X}$) = $\\mu$，樣本均值的期望與原隨機變量的期望相同；\n",
    "* Var($\\bar{X}$) = $\\frac{\\sigma^2}{n}$，其中$n$為每次取樣的樣本量，\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.99008474793 -0.0208546895623\n",
      "1.00750814281 0.00347718092382\n",
      "0.672067720702 0.00687662521186\n",
      "0.503784014261 0.00284508641179\n",
      "0.20016653808 0.000791586359448\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy import stats\n",
    "\n",
    "def mean_and_std_of_sample_mean(ss=[], group_n=100):\n",
    "    \"\"\"\n",
    "    不同大小样本均值的均值以及标准差\n",
    "    \"\"\"\n",
    "    norm_dis = stats.norm(0, 2)  # 定义一个均值为0，标准差为2的正态分布\n",
    "    for n in ss:\n",
    "        sample_mean = []  # 收集每次取样的样本均值\n",
    "        for i in range(group_n):\n",
    "            sample = norm_dis.rvs(n)  # 取样本量为n的样本\n",
    "            sample_mean.append(np.mean(sample))  # 计算该组样本的均值\n",
    "        print(np.std(sample_mean), np.mean(sample_mean))\n",
    "\n",
    "sample_size = [1, 4, 9, 16, 100]  # 每组试验的样本量\n",
    "group_num = 10000\n",
    "mean_and_std_of_sample_mean(ss=sample_size, group_n=group_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 樣本均值的期望和方差\n",
    "\n",
    "設隨機變量$X$的一組樣本為$x$，則樣本的均值$\\bar{x} = \\frac{1}{n} \\displaystyle \\sum_{i=1}^{n}x_i$。此時的樣本$x$與樣本均值$x$都是確定的數值，不具有隨機行。但是，如果我們取了很多組樣本：$x^{(1)}, x^{(2)}, ...$那麼這些樣本的均值$\\bar{x}^{(1)}, \\bar{x}^{(2)}, ...$就可以組成一個新的隨機變量，可以記做$\\bar{X}$，每一個樣本均值也可以看做是從該隨機變量中抽樣所得。<br>\n",
    "\n",
    "樣本均值$\\bar{X}$這個隨機變量$X$的函數。根據期望和方差的定義，我們可以求出樣本均值的期望和方差。假設隨機變量$X$的期望和方差分別為$\\mu$和$\\sigma^2$\n",
    "* $\\E(\\bar{X}) = \\mu$，樣本均值的期望與原隨機變量的期望相同；\n",
    "* $D(\\bar{X}) = \\frac{\\sigma^2}{n}$，其中$n$ 為每次取樣的樣本量，這裡的$n$不表示樣本組數，而是單組中的樣本量；樣本組數在這裡並沒有體現。這是因為**$\\bar{X}$的随机性是在获取单组样本时体现出来的（即结果的不确定性），跟组数无关（当每组样本获得之后，数据就不在具有随机性了）。由此可见，每次采样的样本量越多，得到的样本均值的方差也越小，也就表示更加准确，但是取样所用的时间和成本也同时增加了。这就需要在准确型和成本之间做一个权衡。<br>\n",
    "\n",
    "<br>\n",
    "下面用程序做一個測試，測試的是樣本均值的標準差隨著樣本量的變化而發生的變化，如果方差縮小$n$倍，那麼理論上標準差會縮小$\\sqrt n$倍。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.99183803618 0.0461229296359\n",
      "1.00674682296 0.0177540329668\n",
      "0.668143024892 0.00299211910315\n",
      "0.498323040688 -0.00523627140067\n",
      "0.201260608929 0.00134588313727\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy import stats\n",
    "\n",
    "def mean_and_std_of_sample_mean(ss=[], group_n=100):\n",
    "    \"\"\"\n",
    "    不同大小样本均值的均值以及标准差\n",
    "    \"\"\"\n",
    "    norm_dis = stats.norm(0, 2)  # 定义一个均值为0，标准差为2的正态分布\n",
    "    for n in ss:\n",
    "        sample_mean = []  # 收集每次取样的样本均值\n",
    "        for i in range(group_n):\n",
    "            sample = norm_dis.rvs(n)  # 取样本量为n的样本\n",
    "            sample_mean.append(np.mean(sample))  # 计算该组样本的均值\n",
    "        print(np.std(sample_mean), np.mean(sample_mean))\n",
    "\n",
    "sample_size = [1, 4, 9, 16, 100]  # 每组试验的样本量\n",
    "group_num = 10000\n",
    "mean_and_std_of_sample_mean(ss=sample_size, group_n=group_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "具體的證明過程，可以參考<a href=\"https://onlinecourses.science.psu.edu/stat414/node/167\">Mean and Variance of Sample Mean</a>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
